//package com.fastCms.business.mall.manage.impl;
//
//import com.alibaba.fastjson.JSON;
//import com.alibaba.fastjson.JSONObject;
//import com.fastCms.business.bim.plugins.excel.DateUtils;
//import com.fastCms.business.bim.service.ProductService;
//import com.fastCms.business.bim.service.impl.ProductImageService;
//import com.fastCms.business.frame.constant.CommonConst;
//import com.fastCms.business.frame.constant.ResultCodeConst;
//import com.fastCms.business.frame.exception.BusinessException;
//import com.fastCms.business.frame.pojo.PageParam;
//import com.fastCms.business.frame.pojo.po.IdListPO;
//import com.fastCms.business.frame.pojo.po.StatusPO;
//import com.fastCms.business.frame.response.ApiResponse;
//import com.fastCms.business.frame.response.ResponseUtil;
//import com.fastCms.business.frame.utils.BeanConvertUtil;
//import com.fastCms.business.frame.utils.CommonsUtil;
//import com.fastCms.business.frame.utils.RedisUtil;
//import com.fastCms.business.mall.deal.ProductDealService;
//import com.fastCms.business.mall.enums.ProductHasSkuEnum;
//import com.fastCms.business.mall.enums.ProductStoreStatus;
//import com.fastCms.business.mall.manage.ProductManageService;
//import com.fastCms.business.mall.mapper.ProductMapper;
//import com.fastCms.business.mall.pojo.entity.*;
//import com.fastCms.business.mall.pojo.po.*;
//import com.fastCms.business.mall.pojo.vo.*;
//import com.github.pagehelper.PageHelper;
//import com.github.pagehelper.PageInfo;
//import com.google.common.base.Joiner;
//import com.google.common.collect.Lists;
//import com.google.common.collect.Maps;
//import com.google.common.collect.Sets;
//import lombok.extern.slf4j.Slf4j;
//import org.apache.commons.lang3.StringUtils;
//import org.springframework.beans.BeanUtils;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.data.redis.core.StringRedisTemplate;
//import org.springframework.stereotype.Component;
//import org.springframework.transaction.annotation.Transactional;
//import org.springframework.util.CollectionUtils;
//
//import java.math.BigDecimal;
//import java.util.*;
//import java.util.concurrent.TimeUnit;
//import java.util.stream.Collectors;
//
///**
// * 杭州人参大健康管理有限公司 版权所有 Copyright 2019<br>
// *
// * @Description: <br>
// * @Project: healthPro <br>
// * @CreateDate: Created in 2019年4月9日 下午6:16:56 <br>
// * @Author: < a href="jiahui.zhao@healthpro.vip">jiahui.zhao</ a>
// */
//@Transactional(rollbackFor = Exception.class)
//@Component
//@Slf4j
//public class ProductManageServiceImpl implements ProductManageService {
//
//    @Autowired
//    private ProductService productServiceImpl;
//
//    @Autowired
//    private ProductImageService productImageServiceImpl;
//
//    @Autowired
//    private ProductMapper productMapper;
//
//    @Autowired
//    private ProductClassRelationService productClassRelationServiceImpl;
//
//    @Autowired
//    private ProductSpecValueService productSpecValueServiceImpl;
//
//    @Autowired
//    private ProductSpecRelService productSpecRelServiceImpl;
//
//    @Autowired
//    private ProductSkuService productSkuServiceImpl;
//
//    @Autowired
//    private ProductAttributeRelationService productAttributeRelationServiceImpl;
//
//    @Autowired
//    private ProductSpecService productSpecServiceImpl;
//
//    @Autowired
//    private ProductTagService productTagServiceImpl;
//
//    @Autowired
//    private ProductAttributeRelationMapper productAttributeRelationMapper;
//
//    @Autowired
//    private StoreService storeServiceImpl;
//
//    @Autowired
//    private HospitalService hospitalServiceImpl;
//
//    @Autowired
//    private ProductClassRelationMapper productClassRelationMapper;
//
//    @Autowired
//    private WechatDealService wechatDealServieImpl;
//
//
//    @Autowired
//    private ProductDealService productDealServiceImpl;
//
//    public ApiResponse<String> saveOrUpdateProduct(ProductInfoEditPO editProductInfoPO) throws BusinessException {
//        Date now = new Date();
//        Product product = null;
//        Product repeatCodeProduct = null;
//        String productId = editProductInfoPO.getProduct().getId();
//        // 新增
//        if (StringUtils.isBlank(productId)) {
//            // 商品code是否重复
//            if (StringUtils.isNotBlank(editProductInfoPO.getProduct().getProductCode())) {
//                repeatCodeProduct = productServiceImpl.findByOrganizeCodeAndProductCode(
//                    editProductInfoPO.getProduct().getOrganizeCode(),
//                    editProductInfoPO.getProduct().getProductCode());
//            }
//            if (repeatCodeProduct != null) {
//                log.error("------result:error------reason:商品code重复 organizeCode:{},brandCode:{}",
//                    editProductInfoPO.getProduct().getOrganizeCode(),
//                    editProductInfoPO.getProduct().getProductCode());
//                return ResponseUtil.fail(ResultCodeConst.PRODUCT.PRODUCT_CODE_BE_EXIST,
//                    ResultCodeConst.PRODUCT.PRODUCT_CODE_BE_EXIST_MSG);
//            }
//
//            product = new Product();
//            BeanUtils.copyProperties(editProductInfoPO.getProduct(), product);
//
//            // 立即上架
//            if (ProductStoreStatus.ON_SALE.getCode().equals(editProductInfoPO.getProduct().getStoreStatus())) {
//                product.setOnSaleTime(now);
//            } else if (ProductStoreStatus.OFF_SALE.getCode().equals(editProductInfoPO.getProduct().getStoreStatus())
//                && editProductInfoPO.getProduct().getOnSaleTime() != null
//                && editProductInfoPO.getProduct().getOnSaleTime().compareTo(DateUtils.addMinutes(now, 1)) <= 0) {
//                // 下架并且上架时间在当前时间之前，也做按当前时间上架
//                product.setStoreStatus(ProductStoreStatus.ON_SALE.getCode());
//                product.setOnSaleTime(now);
//            }
//            product.setStoreBaseSaleCount(editProductInfoPO.getProduct().getStoreBaseSaleCount());
//            product.setProductNumber(CommonsUtil.getProductNumber());
//            CommonsUtil.initEntity(product);
//
//            productId = product.getId();
//
//            // 定时上架
//            productToOnSale(productId, product.getStoreStatus(), product.getOnSaleTime());
//
//        } else {
//            product = productServiceImpl.findById(editProductInfoPO.getProduct().getId());
//            if (product == null) {
//                log.error("------result:error------reason:根据productId={},查无数据", editProductInfoPO.getProduct().getId());
//                return ResponseUtil.fail(ResultCodeConst.DATA_ERROR, ResultCodeConst.DATA_ERROR_MSG);
//            }
//            // 商品code修改了 判断是否重复
//            if (StringUtils.isNotBlank(editProductInfoPO.getProduct().getProductCode())
//                && StringUtils.isNotBlank(product.getProductCode())
//                && (!editProductInfoPO.getProduct().getProductCode().equals(product.getProductCode()))) {
//                repeatCodeProduct = productServiceImpl.findByOrganizeCodeAndProductCode(
//                    editProductInfoPO.getProduct().getOrganizeCode(),
//                    editProductInfoPO.getProduct().getProductCode());
//            }
//            if (repeatCodeProduct != null) {
//                log.error("------result:error------reason:商品code重复 organizeCode:{},brandCode:{}",
//                    editProductInfoPO.getProduct().getOrganizeCode(),
//                    editProductInfoPO.getProduct().getProductCode());
//                return ResponseUtil.fail(ResultCodeConst.PRODUCT.PRODUCT_CODE_BE_EXIST,
//                    ResultCodeConst.PRODUCT.PRODUCT_CODE_BE_EXIST_MSG);
//            }
//            // 原先的状态
//            Integer oldStoreStatus = product.getStoreStatus();
//            // 原先的上架时间
//            Date oldOnSaleTime = product.getOnSaleTime();
//            BeanUtils.copyProperties(editProductInfoPO.getProduct(), product);
//            product.setOriginalPrice(editProductInfoPO.getProduct().getOriginalPrice());
//            if (editProductInfoPO.getProduct().getStoreBaseSaleCount() == null) {
//                product.setStoreBaseSaleCount(0);
//            }
//
//            // 修改上下架状态
//            if (!oldStoreStatus.equals(editProductInfoPO.getProduct().getStoreStatus())
//                || oldOnSaleTime != editProductInfoPO.getProduct().getOnSaleTime()) {
//                if (ProductStoreStatus.ON_SALE.getCode().equals(editProductInfoPO.getProduct().getStoreStatus())) {
//                    product.setOnSaleTime(now);
//                } else if (ProductStoreStatus.OFF_SALE.getCode()
//                    .equals(editProductInfoPO.getProduct().getStoreStatus())) {
//                    product.setOnSaleTime(editProductInfoPO.getProduct().getOnSaleTime());
//                    // 下架并且上架时间在当前时间之前，也做按当前时间上架
//                    if (editProductInfoPO.getProduct().getOnSaleTime() != null && editProductInfoPO.getProduct()
//                        .getOnSaleTime().compareTo(DateUtils.addMinutes(now, 1)) <= 0) {
//                        product.setStoreStatus(ProductStoreStatus.ON_SALE.getCode());
//                        product.setOnSaleTime(now);
//                    }
//                }
//                // 定时上架
//                productToOnSale(productId, product.getStoreStatus(), product.getOnSaleTime());
//            }
//        }
//        // 门店
//        String storeIds = "";
//        if (!CollectionUtils.isEmpty(editProductInfoPO.getProduct().getStoreIds())) {
//            storeIds = JSON.toJSONString(editProductInfoPO.getProduct().getStoreIds());
//
//        }
//        product.setStoreIds(storeIds);
//        // 医院
//        String hospitalIds = "";
//        if (!CollectionUtils.isEmpty(editProductInfoPO.getProduct().getHospitalIds())) {
//            hospitalIds = JSON.toJSONString(editProductInfoPO.getProduct().getHospitalIds());
//        }
//        // 首图
//        if (!CollectionUtils.isEmpty(editProductInfoPO.getImageUrls())) {
//            product.setMainImageUrl(editProductInfoPO.getImageUrls().get(0));
//        }
//        product.setHospitalIds(hospitalIds);
//        productServiceImpl.saveOrUpdate(product);
//
//        // 组织编码
//        String organizeCode = product.getOrganizeCode();
//
//        // 处理商品图片
//        saveProductImages(productId, editProductInfoPO.getImageUrls());
//
//        // 处理商品分类
//        saveProductClassRelation(productId, organizeCode, editProductInfoPO.getClassIds());
//
//        // 处理商品属性
//        saveProductAttributes(productId, organizeCode, editProductInfoPO.getProductAttributeRelations());
//
//        // 处理商品标签
//        saveProductTags(productId, organizeCode, editProductInfoPO.getProductTags());
//
//        // 处理商品sku
//        saveProductSku(product, editProductInfoPO.getProductSpecRelValues(), editProductInfoPO.getProductSkus());
//
//        return ResponseUtil.success(productId);
//
//    }
//
//    @Override
//    public ApiResponse<ProductPageInfoVO> showPage(PageParam<ProductQueryPO> pageParam) {
//        ProductPageInfoVO vo = new ProductPageInfoVO();
//        ProductQueryPO queryFields = pageParam.getQueryFields();
//        if (StringUtils.isBlank(pageParam.getOrderBy())) {
//            pageParam.setOrderBy(" create_time DESC ");
//        }
//        // 分页信息
//        PageInfo<ProductVO> showVOPageInfo = PageHelper
//            .startPage(pageParam.getPageNum(), pageParam.getPageSize(), pageParam.getOrderBy())
//            .doSelectPageInfo(() -> {
//                productMapper.findProduct(queryFields);
//            });
//        // showVOPageInfo.setTotal(productServiceImpl.countProduct(queryFields));
//        vo.setPageInfo(showVOPageInfo);
//
//        // 统计数据
//        ProductQueryPO queryProductPO = new ProductQueryPO();
//        if (StringUtils.isNotBlank(queryFields.getOrganizeCode())) {
//            queryProductPO.setOrganizeCode(queryFields.getOrganizeCode());
//        }
//        queryProductPO.setTabStatus(ProductTabStatus.ON_SELL.getCode());
//        vo.setOnSellCount(productServiceImpl.countProduct(queryProductPO));
//        queryProductPO.setTabStatus(ProductTabStatus.SELL_OUT.getCode());
//        vo.setSellOutCount(productServiceImpl.countProduct(queryProductPO));
//        queryProductPO.setTabStatus(ProductTabStatus.OFF_SELL.getCode());
//        vo.setOffSellCount(productServiceImpl.countProduct(queryProductPO));
//        return ResponseUtil.success(vo);
//    }
//
//    @Override
//    public ApiResponse<Boolean> deleteProduct(String productId) {
//        Product product = productServiceImpl.findById(productId);
//        if (product == null) {
//            log.error("------result:error------reason:根据id={},查无数据", productId);
//            return ResponseUtil.fail(ResultCodeConst.DATA_ERROR, ResultCodeConst.DATA_ERROR_MSG);
//        }
//        // 上架状态的商品不能删除
//        if (ProductStoreStatus.ON_SALE.getCode().equals(product.getStoreStatus())) {
//            log.error("------result:error------reason:根据id={},查无数据", productId);
//            return ResponseUtil.fail(ResultCodeConst.PRODUCT.PRODUCT_ON_SALE_CAN_NOT_DELETE,
//                ResultCodeConst.PRODUCT.PRODUCT_ON_SALE_CAN_NOT_DELETE_MSG);
//        }
//        product.setState(CommonConst.STATE.INVALID);
//        boolean result = productServiceImpl.updateById(product);
//        if (!result) {
//            return ResponseUtil.fail(ResultCodeConst.DATA_ERROR_MSG);
//        }
//
//        // 企业福利商城下架
//        CompProduct compProduct = compProductServiceImpl.findByProductId(product.getId());
//        if (compProduct != null) {
//            compProduct.setCompStoreStatus(ProductStoreStatus.OFF_SALE.getCode());
//            boolean updateResult = compProductServiceImpl.updateById(compProduct);
//            if (!updateResult) {
//                return ResponseUtil.fail(ResultCodeConst.DATA_ERROR_MSG);
//            }
//        }
//
//        // 删除商品分类关系
//        List<ProductClassRelation> relations = productClassRelationServiceImpl.findByProductId(productId);
//        if (!CollectionUtils.isEmpty(relations)) {
//            relations.forEach(relation -> {
//                relation.setState(CommonConst.STATE.INVALID);
//            });
//            productClassRelationServiceImpl.saveOrUpdateBatch(relations);
//        }
//
//        return ResponseUtil.success(true);
//    }
//
//    @Override
//    public ApiResponse<Boolean> changeProductStoreStatus(List<StatusPO> statusPOS) {
//        Map<String, Integer> map = statusPOS.stream().collect(Collectors.toMap(StatusPO::getId, StatusPO::getStatus));
//        List<Product> productList = (List<Product>) productServiceImpl.listByIds(map.keySet());
//        List<String> offSaleProductIds = Lists.newArrayList();
//        if (!CollectionUtils.isEmpty(productList)) {
//            Date now = new Date();
//            productList.forEach(product -> {
//                Integer storeStatus = map.get(product.getId());
//                // 修改了上下架状态
//                if (product.getStoreStatus() != storeStatus) {
//                    // 上架，设置上架时间
//                    if (ProductStoreStatus.ON_SALE.getCode().equals(storeStatus)) {
//                        product.setOnSaleTime(now);
//                    } else {
//                        product.setOnSaleTime(null);
//                        offSaleProductIds.add(product.getId());
//                    }
//                    product.setStoreStatus(map.get(product.getId()));
//                }
//
//            });
//            boolean result = productServiceImpl.saveOrUpdateBatch(productList);
//
//            if (!result) {
//                return ResponseUtil.fail(ResultCodeConst.DATA_ERROR_MSG);
//            }
////			// 如果是批量下架，企业福利商城同步下架
////			if(!CollectionUtils.isEmpty(offSaleProductIds)) {
////				List<CompProduct> compProducts = compProductServiceImpl.findByProductIds(offSaleProductIds);
////				if(!CollectionUtils.isEmpty(compProducts)) {
////					compProducts.forEach(compProduct ->{
////						compProduct.setCompStoreStatus(ProductStoreStatus.OFF_SALE.getCode());
////					});
////					compProductServiceImpl.saveOrUpdateBatch(compProducts);
////				}
////			}
//        }
//        return ResponseUtil.success(true);
//    }
//
//    @Override
//    public ApiResponse<Boolean> changeProductRemainStock(ProductStockPO productStockPO) {
//        Product product = productServiceImpl.findById(productStockPO.getProductId());
//        if (product == null) {
//            log.error("------result:error------reason:根据id={},查无数据", productStockPO.getProductId());
//            return ResponseUtil.fail(ResultCodeConst.DATA_ERROR, ResultCodeConst.DATA_ERROR_MSG);
//        }
//        product.setRemainStock(productStockPO.getStock());
//        boolean result = productServiceImpl.updateById(product);
//        if (!result) {
//            return ResponseUtil.fail(ResultCodeConst.DATA_ERROR_MSG);
//        }
//
//        return ResponseUtil.success(true);
//    }
//
//    @Override
//    public ApiResponse<ProductInfoShowVO> showProductInfo(String productId) {
//        ProductInfoShowVO productInfoShowVO = new ProductInfoShowVO();
//
//        // 商品
//        Product product = productServiceImpl.findById(productId);
//        if (product == null) {
//            log.error("------result:error------reason:根据id={},查无数据", productId);
//            return ResponseUtil.fail(ResultCodeConst.DATA_ERROR, ResultCodeConst.DATA_ERROR_MSG);
//        }
//        ProductVO productVO = new ProductVO();
//        BeanUtils.copyProperties(product, productVO);
//        if (!StringUtils.isBlank(product.getStoreIds())) {
//            List<String> storeIds = JSON.parseArray(product.getStoreIds(), String.class);
//            productVO.setStoreIds(storeIds);
//        }
//        if (!StringUtils.isBlank(product.getHospitalIds())) {
//            List<Long> hospitalIds = JSON.parseArray(product.getHospitalIds(), Long.class);
//            productVO.setHospitalIds(hospitalIds);
//        }
//        productInfoShowVO.setProduct(productVO);
//
//        // 商品图片
//        List<ProductImage> producImages = productImageServiceImpl.findByProductId(productId);
//        if (CollectionUtils.isEmpty(producImages)) {
//            log.error("------result:error------reason:根据productId={},查无数据", product.getId());
//            return ResponseUtil.fail(ResultCodeConst.DATA_ERROR, ResultCodeConst.DATA_ERROR_MSG);
//        }
//        List<String> producImageVOS = producImages.stream().map(ProductImage::getImageUrl).collect(Collectors.toList());
//
//        productInfoShowVO.setProductImages(producImageVOS);
//
//        // 商品分类
//        // 处理商品分类
//        List<ProductClassRelation> classRelations = productClassRelationServiceImpl.findByProductId(productId);
//        if (!CollectionUtils.isEmpty(classRelations)) {
//            List<String> classIds = classRelations.stream().map(ProductClassRelation::getClassId)
//                .collect(Collectors.toList());
//            productInfoShowVO.setClassIds(classIds);
//        } else {
//            productInfoShowVO.setClassIds(Collections.emptyList());
//        }
//
//        // 商品属性
//        List<ProductAttributeRelation> attrbuteRelations = productAttributeRelationServiceImpl
//            .findByProductId(productId);
//        if (!CollectionUtils.isEmpty(attrbuteRelations)) {
//            List<ProductAttributeRelationVO> relationVOS = BeanConvertUtil.convertList(attrbuteRelations, ProductAttributeRelationVO.class);
//            productInfoShowVO.setProductAttributeRelations(relationVOS);
//        } else {
//            productInfoShowVO.setProductAttributeRelations(Collections.emptyList());
//        }
//
//        // 商品标签
//        List<ProductTag> tags = productTagServiceImpl.findByProductId(productId);
//        if (!CollectionUtils.isEmpty(tags)) {
//            List<String> tagNames = tags.stream().map(ProductTag::getTagName).collect(Collectors.toList());
//            productInfoShowVO.setProductTags(tagNames);
//        } else {
//            productInfoShowVO.setProductTags(Collections.emptyList());
//        }
//
//        return ResponseUtil.success(productInfoShowVO);
//    }
//
//    @Override
//    public ApiResponse<ProductSkuInfoShowVO> showProductSkuInfo(String productId) {
//        ProductSkuInfoShowVO productInfoShowVO = new ProductSkuInfoShowVO();
//        // 商品
//        Product product = productServiceImpl.getById(productId);
//        if (product == null) {
//            log.error("------result:error------reason:根据id={},查无数据", productId);
//            return ResponseUtil.fail(ResultCodeConst.DATA_ERROR, ResultCodeConst.DATA_ERROR_MSG);
//        }
//        BeanUtils.copyProperties(product, productInfoShowVO);
//        productInfoShowVO.setProductId(productId);
//
//        // 商品规格和规格值列表
//        List<ProductSpecRel> productSpecRels = productSpecRelServiceImpl.findByProductId(productId);
//        if (!CollectionUtils.isEmpty(productSpecRels)) {
//            List<ProductSpecRelValueVO> productSpecRelValues = productSpecRels.stream().map(relValue -> {
//                ProductSpecRelValueVO relValueVO = new ProductSpecRelValueVO();
//                BeanUtils.copyProperties(relValue, relValueVO);
//
//                ProductSpec productSpec = productSpecServiceImpl.findById(relValue.getSpecId());
//                if (productSpec != null) {
//                    relValueVO.setSpecName(productSpec.getSpecName());
//                }
//
//                List<ProductSpecValue> values = productSpecValueServiceImpl.findByProductIdAndSpecId(productId,
//                    relValue.getSpecId());
//                if (!CollectionUtils.isEmpty(values)) {
//                    List<ProductSpecValueVO> productSpecValues = BeanConvertUtil.convertList(values, ProductSpecValueVO.class);
//                    relValueVO.setProductSpecValues(productSpecValues);
//                } else {
//                    relValueVO.setProductSpecValues(Collections.emptyList());
//                }
//
//                return relValueVO;
//            }).collect(Collectors.toList());
//
//            productInfoShowVO.setProductSpecRelValues(productSpecRelValues);
//        } else {
//            productInfoShowVO.setProductSpecRelValues(Collections.emptyList());
//        }
//
//        // 商品sku列表
//        List<ProductSku> skus = productSkuServiceImpl.findByProductId(productId);
//        if (!CollectionUtils.isEmpty(skus)) {
//            List<ProductSkuVO> productSkuVOS = skus.stream().map(sku -> {
//                ProductSkuVO skuVO = BeanConvertUtil.convertBean(sku, ProductSkuVO.class);
//                JSONObject obj = JSON.parseObject(sku.getSkuDesc());
//                String description = Joiner.on(",").join(obj.values());
//                skuVO.setDescription(description);
//                return skuVO;
//            }).collect(Collectors.toList());
//            productInfoShowVO.setProductSkus(productSkuVOS);
//        } else {
//            productInfoShowVO.setProductSkus(Collections.emptyList());
//        }
//        return ResponseUtil.success(productInfoShowVO);
//    }
//
//    @Override
//    public ApiResponse<Boolean> productOnSaleInTime(String productId) {
//        Product product = productServiceImpl.findById(productId);
//        if (product == null) {
//            log.error("------result:error------reason:根据id={},查无数据", productId);
//            return ResponseUtil.fail(ResultCodeConst.DATA_ERROR, ResultCodeConst.DATA_ERROR_MSG);
//        }
//        // 下架且设置了自定义上架时间
//        if (ProductStoreStatus.OFF_SALE.getCode().equals(product.getStoreStatus()) && product.getOnSaleTime() != null) {
//            Date now = new Date();
//            product.setStoreStatus(ProductStoreStatus.ON_SALE.getCode());
//            product.setOnSaleTime(now);
//            productServiceImpl.updateById(product);
//            return ResponseUtil.success(true);
//        }
//
//        return ResponseUtil.fail(ResultCodeConst.DATA_ERROR_MSG);
//    }
//
//    @Override
//    public ApiResponse<PageInfo<ProductSelectorVO>> productSelector(PageParam<ProductQuerySelectorPO> pageParam) {
//        if (StringUtils.isBlank(pageParam.getOrderBy())) {
//            pageParam.setOrderBy(" p.create_time DESC ");
//        }
//        ProductQuerySelectorPO queryFields = pageParam.getQueryFields();
//        PageInfo<ProductSelectorVO> showVOPageInfo = PageHelper
//            .startPage(pageParam.getPageNum(), pageParam.getPageSize(), pageParam.getOrderBy())
//            .doSelectPageInfo(() -> {
//                productMapper.productSelector(queryFields);
//            });
//        return ResponseUtil.success(showVOPageInfo);
//    }
//
//    @Override
//    public ApiResponse<List<ProductVO>> showProductList(IdListPO idListPO) {
//        if (idListPO == null || CollectionUtils.isEmpty(idListPO.getIdList())) {
//            return ResponseUtil.success(Collections.emptyList());
//        }
//        List<Product> products = productServiceImpl.findByIdList(idListPO.getIdList());
//
//        if (CollectionUtils.isEmpty(products)) {
//            return ResponseUtil.success(Collections.emptyList());
//        }
//
//        List<ProductVO> productVOS = BeanConvertUtil.convertList(products, ProductVO.class);
//        return ResponseUtil.success(productVOS);
//    }
//
//    @Override
//    public ApiResponse<ProductVO> showProductBaseInfo(String productId) {
//        // 商品
//        Product product = productServiceImpl.findById(productId);
//        if (product == null) {
//            log.error("------result:error------reason:根据id={},查无数据", productId);
//            return ResponseUtil.fail(ResultCodeConst.DATA_ERROR, ResultCodeConst.DATA_ERROR_MSG);
//        }
//        ProductVO productVO = new ProductVO();
//        BeanUtils.copyProperties(product, productVO);
//        return ResponseUtil.success(productVO);
//    }
//
//    @Override
//    public ApiResponse<Boolean> changeProductSkuStocks(ProductSkuStockPO productSkuStockPO) {
//        if (productSkuStockPO == null || CollectionUtils.isEmpty(productSkuStockPO.getProductSkuStocks())) {
//            return ResponseUtil.fail(ResultCodeConst.PARAM_ERROR, ResultCodeConst.PARAM_ERROR_MSG);
//        }
//
//        Product product = productServiceImpl.findById(productSkuStockPO.getProductId());
//        if (product == null) {
//            log.error("[批量修改商品sku库存]------result:error------reason:根据productId={},查无数据",
//                productSkuStockPO.getProductId());
//            return ResponseUtil.fail(ResultCodeConst.DATA_ERROR, ResultCodeConst.DATA_ERROR_MSG);
//        }
//
//        // 查询商品下的所有sku
//        List<ProductSku> skus = productSkuServiceImpl.findByProductId(productSkuStockPO.getProductId());
//        if (CollectionUtils.isEmpty(skus)) {
//            return ResponseUtil.fail(ResultCodeConst.DATA_ERROR, ResultCodeConst.DATA_ERROR_MSG);
//        }
//
//        // 映射到map
//        Map<String, Integer> stockMap = productSkuStockPO.getProductSkuStocks().stream()
//            .collect(Collectors.toMap(ProductSkuStock::getId, ProductSkuStock::getStock));
//
//        // 更新sku库存
//        for (ProductSku sku : skus) {
//            Integer stock = stockMap.get(sku.getId());
//            if (stock != null) {
//                sku.setSkuStock(stock);
//            }
//        }
//        productSkuServiceImpl.saveOrUpdateBatch(skus);
//
//        // 更新商品剩余库存
//        int stockSum = skus.stream().collect(Collectors.summingInt(ProductSku::getSkuStock));
//        product.setRemainStock(stockSum);
//        productServiceImpl.updateById(product);
//
//        return ResponseUtil.success(true);
//    }
//
//    @Override
//    public ApiResponse<PageInfo<AppProductListVO>> showProducts(PageParam<AppQueryProductPO> pageParam) {
//        if (StringUtils.isBlank(pageParam.getOrderBy())) {
//            pageParam.setOrderBy(" p.create_time DESC ");
//        }
//        AppQueryProductPO queryFields = pageParam.getQueryFields();
//        PageInfo<AppProductListVO> showVOPageInfo = PageHelper
//            .startPage(pageParam.getPageNum(), pageParam.getPageSize(), pageParam.getOrderBy())
//            .doSelectPageInfo(() -> {
//                productMapper.findAppProductList(queryFields);
//            });
//        return ResponseUtil.success(showVOPageInfo);
//    }
//
//    @Override
//    public ApiResponse<AppProductDetailVO> showProductDetail(String productId) {
//        AppProductDetailVO appProductDetailVO = new AppProductDetailVO();
//
//        // 商品
//        Product product = productServiceImpl.getById(productId);
//        if (product == null) {
//            log.error("------result:error------reason:根据id={},查无数据", productId);
//            return ResponseUtil.fail(ResultCodeConst.DATA_ERROR, ResultCodeConst.DATA_ERROR_MSG);
//        }
//        product.setStoreSaleCount(product.getStoreSaleCount() + product.getStoreBaseSaleCount());
//        BeanUtils.copyProperties(product, appProductDetailVO);
//        appProductDetailVO.setStatus(product.getState());
//
//        // 商品图片
//        List<ProductImage> producImages = productImageServiceImpl.findByProductId(productId);
//        if (CollectionUtils.isEmpty(producImages)) {
//            log.error("------result:error------reason:根据productId={},查无数据", product.getId());
//            return ResponseUtil.fail(ResultCodeConst.DATA_ERROR, ResultCodeConst.DATA_ERROR_MSG);
//        }
//        List<String> producImageVOS = producImages.stream().map(ProductImage::getImageUrl).collect(Collectors.toList());
//
//        appProductDetailVO.setProductImages(producImageVOS);
//
//        // 商品属性
//        List<ProductAttributeRelationVO> attrbuteRelationVOS = productAttributeRelationMapper
//            .findByProductId(productId);
//        if (!CollectionUtils.isEmpty(attrbuteRelationVOS)) {
//            List<AppProductAttributeVO> relationVOS = BeanConvertUtil.convertList(attrbuteRelationVOS, AppProductAttributeVO.class);
//            appProductDetailVO.setProductAttributes(relationVOS);
//        } else {
//            appProductDetailVO.setProductAttributes(Collections.emptyList());
//        }
//
//        // 填充商品标签
//        appProductDetailVO.setProductTags(getProductTags(productId));
//
////        // 商品所在分类id列表
////        List<String> classIds = productClassRelationMapper.findClassIdsByProductId(productId);
////        appProductDetailVO.setClassIds(classIds);
//
//        return ResponseUtil.success(appProductDetailVO);
//    }
//
//    @Override
//    public ApiResponse<List<HospitalVO>> showHospitals(String productId) {
//        // 商品
//        Product product = productServiceImpl.getById(productId);
//        if (product == null) {
//            log.error("------result:error------reason:根据id={},查无数据", productId);
//            return ResponseUtil.fail(ResultCodeConst.DATA_ERROR, ResultCodeConst.DATA_ERROR_MSG);
//        }
//        List<HospitalVO> hospitalVOS = Collections.emptyList();
//        if (!StringUtils.isBlank(product.getHospitalIds())) {
//            List<Long> hospitalIds = JSON.parseArray(product.getHospitalIds(), Long.class);
//            List<Hospital> hospitals = hospitalServiceImpl.findByIds(hospitalIds);
//            hospitalVOS = hospitals.stream().map(hospital -> {
//                HospitalVO hospitalVO = new HospitalVO();
//                BeanUtils.copyProperties(hospital, hospitalVO);
//                return hospitalVO;
//            }).collect(Collectors.toList());
//        }
//        return ResponseUtil.success(hospitalVOS);
//    }
//
//    @Override
//    public ApiResponse<List<AppProductListVO>> showAppProductList(IdListPO idListPO) {
//        if (idListPO == null || CollectionUtils.isEmpty(idListPO.getIdList())) {
//            return ResponseUtil.success(Collections.emptyList());
//        }
//        List<Product> products = productServiceImpl.findByIdList(idListPO.getIdList());
//
//        if (CollectionUtils.isEmpty(products)) {
//            return ResponseUtil.success(Collections.emptyList());
//        }
//
//        List<AppProductListVO> productVOS = products.stream().map(product -> {
//            AppProductListVO vo = new AppProductListVO();
//            BeanUtils.copyProperties(product, vo);
//            vo.setStoreSaleCount(product.getStoreSaleCount() + product.getStoreBaseSaleCount());
//            return vo;
//        }).collect(Collectors.toList());
//
//        // 填充商品标签
//        productVOS = productDealServiceImpl.fillProductTags(productVOS);
//        return ResponseUtil.success(productVOS);
//    }
//
//
//    @Override
//    public ApiResponse<List<AppProductListVO>> showRecommendProducts(String productId) {
//        Product product = productServiceImpl.findById(productId);
//        if (product == null) {
//            return ResponseUtil.success(Collections.emptyList());
//        }
//
//        List<Product> products = productServiceImpl.findRecommendProducts(productId, product.getCategoryId());
//
//        if (CollectionUtils.isEmpty(products)) {
//            return ResponseUtil.success(Collections.emptyList());
//        }
//
//        List<AppProductListVO> productVOS = products.stream().map(prod -> {
//            AppProductListVO vo = new AppProductListVO();
//            BeanUtils.copyProperties(prod, vo);
//            vo.setStoreSaleCount(prod.getStoreSaleCount() + prod.getStoreBaseSaleCount());
//            return vo;
//        }).collect(Collectors.toList());
//
//        // 填充商品标签
//        return ResponseUtil.success(productVOS);
//    }
//
//    // 保存商品图片
//    private void saveProductImages(String productId, List<String> imageUrls) {
//        // 删除原先的商品图片
//        productImageServiceImpl.removeByProductId(productId);
//
//        if (CollectionUtils.isEmpty(imageUrls)) {
//            return;
//        }
//
//        // 生成商品图片
//        List<ProductImage> productImageList = Lists.newArrayList();
//        int sort = 1;
//        for (String imageUrl : imageUrls) {
//            ProductImage image = new ProductImage();
//            CommonsUtil.initEntity(image);
//            image.setProductId(productId);
//            image.setImageUrl(imageUrl);
//            image.setSort(sort);
//            productImageList.add(image);
//            sort++;
//        }
//        productImageServiceImpl.saveOrUpdateBatch(productImageList);
//    }
//
//    // 保存商品分类关系
//    private void saveProductClassRelation(String productId, String organizeCode, List<String> classIds) {
//        // 删除商品分类关系
//        productClassRelationMapper.deleteByProductId(productId);
//
//        if (CollectionUtils.isEmpty(classIds)) {
//            return;
//        }
//
//        // 重新生成商品分类关系
//        List<ProductClassRelation> addRelations = Lists.newArrayList();
//        for (String classId : classIds) {
//            ProductClassRelation relation = new ProductClassRelation();
//            CommonsUtil.initEntity(relation);
//            relation.setClassId(classId);
//            relation.setProductId(productId);
//            relation.setOrganizeCode(organizeCode);
//            addRelations.add(relation);
//        }
//        productClassRelationServiceImpl.saveOrUpdateBatch(addRelations);
//    }
//
//    // 保存商品属性
//    private void saveProductAttributes(String productId, String organizeCode,
//                                       List<ProductAttributeRelationPO> attributes) {
//        // 删除老的商品属性数据
//        productAttributeRelationMapper.deleteByProductId(productId);
//
//        if (CollectionUtils.isEmpty(attributes)) {
//            return;
//        }
//
//        // 重新生成商品属性数据
//        List<ProductAttributeRelation> addRelations = Lists.newArrayList();
//        int sort = 1;
//        for (ProductAttributeRelationPO relationPO : attributes) {
//            ProductAttributeRelation relation = new ProductAttributeRelation();
//            CommonsUtil.initEntity(relation);
//            relation.setAttributeKeyId(relationPO.getAttributeKeyId());
//            relation.setAttributeValue(StringUtils.trim(relationPO.getAttributeValue()));
//            relation.setSort(sort);
//            relation.setProductId(productId);
//            relation.setOrganizeCode(organizeCode);
//            addRelations.add(relation);
//            sort++;
//        }
//        productAttributeRelationServiceImpl.saveOrUpdateBatch(addRelations);
//    }
//
//    // 保存商品sku
//    private void saveProductSku(Product product, List<ProductSpecRelValuePO> productSpecRelValues,
//                                List<ProductSkuPO> productSkus) throws BusinessException {
//        String productId = product.getId();
//
//        // 处理商品规格和sku
//        List<ProductSpecRel> productSpecRels = productSpecRelServiceImpl.findByProductId(productId);
//
//        List<ProductSku> skus = productSkuServiceImpl.findByProductId(productId);
//
//        List<ProductSpecValue> values = productSpecValueServiceImpl.findByProductId(productId);
//
//        // 没有选中规格 没有sku
//        if (CollectionUtils.isEmpty(productSpecRelValues)) {
//            // 删除商品规格和sku
//            deleteProductSpecRels(productSpecRels);
//            // 删除商品规格值
//            deleteProductSpecValues(values);
//            // 删除商品sku
//            deleteProductSkus(skus);
//
//            // 没有sku的情况下设置为null
//            product.setSkuMinPrice(null);
//            product.setSkuMaxPrice(null);
//            product.setHasSku(ProductHasSkuEnum.NO_SKU.getCode());
//            productServiceImpl.saveOrUpdate(product);
//
//            return;
//        }
//        // 选中了规格 有sku
//        // 是否修改了规格sku
//        boolean editSku = false;
//        // 是否修改了规格（规格或顺序）
//        boolean editSpec = isEditSpec(productSpecRels, productSpecRelValues);
//
//        // 修改了规格
//        if (editSpec) {
//            // 删除商品规格和sku
//            deleteProductSpecRels(productSpecRels);
//        } else {
//            // 是否修改了规格sku
//            editSku = isEditSku(values, productSpecRelValues);
//        }
//        // 删除商品下的所有规格值和所有sku
//        if (editSpec || editSku) {
//            // 删除商品规格值
//            deleteProductSpecValues(values);
//            // 删除商品sku
//            deleteProductSkus(skus);
//        }
//
//        // 选中商品规格
//        List<Set<ProductSpecValue>> specValueList = Lists.newArrayList();
//
//        // 保存商品规格关系
//        int viewSort = 1;
//        List<ProductSpecRel> relList = Lists.newArrayList();
//        for (ProductSpecRelValuePO productSpecRelValuePO : productSpecRelValues) {
//            ProductSpecRel rel = null;
//            // 判断是否修改了规格
//            if (editSpec) {
//                rel = new ProductSpecRel();
//                CommonsUtil.initEntity(rel);
//                rel.setProductId(product.getId());
//                rel.setSpecId(productSpecRelValuePO.getSpecId());
//                rel.setViewSort(viewSort);
//                relList.add(rel);
//            }
//
//            viewSort++;
//
//            // 需要是有序的,保证sku顺序正确
//            Set<ProductSpecValue> addProductSpecValues = saveProductSpecValues(productId,
//                productSpecRelValuePO.getSpecId(), productSpecRelValuePO.getProductSpecValues());
//
//            specValueList.add(addProductSpecValues);
//        }
//        // 修改了规格关系 重新保存规格关系
//        if (editSpec) {
//            productSpecRelServiceImpl.saveOrUpdateBatch(relList);
//        }
//
//        // 规格id列表
//        List<String> specIds = relList.stream().map(ProductSpecRel::getSpecId).collect(Collectors.toList());
//
//        // 要保存的sku列表
//        List<ProductSku> skuList = Lists.newArrayList();
//
//        // 笛卡尔积计算出所有sku组合
//        Set<List<ProductSpecValue>> skuSet = Sets.cartesianProduct(specValueList);
//
//        // sku参数与计算出的sku数量对不上
//        if (CollectionUtils.isEmpty(productSkus) || productSkus.size() != skuSet.size()) {
//            throw new BusinessException(ResultCodeConst.PARAM_ERROR, ResultCodeConst.PARAM_ERROR_MSG);
//        }
//
//        List<ProductSpec> specList = productSpecServiceImpl.findByIds(specIds);
//
//        Map<String, String> skuDescMap = specList.stream()
//            .collect(Collectors.toMap(ProductSpec::getId, ProductSpec::getSpecName));
//
//        int skuSort = 0;
//
//        // 不是新的sku,取原先的id更新
//        boolean notNewSku = !(editSpec || editSku) && (skus.size() == skuSet.size());
//        for (List<ProductSpecValue> specValue : skuSet) {
//            List<Long> idList = specValue.stream().map(ProductSpecValue::getId).collect(Collectors.toList());
//
//            // sku规格id的组合值
//            String skuAttr = Joiner.on(",").join(idList);
//            // sku规格值的组合值
//            Map<String, String> descMap = specValue.stream().collect(
//                Collectors.toMap(value -> (skuDescMap.get(value.getSpecId())), ProductSpecValue::getValue));
//
//            ProductSku sku = new ProductSku();
//            BeanUtils.copyProperties(productSkus.get(skuSort), sku);
//            sku.setProductId(productId);
//            sku.setSkuAttr(skuAttr);
//            sku.setSkuDesc(JSON.toJSONString(descMap));
//            sku.setViewSort(skuSort + 1);
//
//            if (notNewSku) {
//                sku.setId(skus.get(skuSort).getId());
//            } else {
//                CommonsUtil.initEntity(sku);
//            }
//
//            skuList.add(sku);
//            skuSort++;
//        }
//
//        productSkuServiceImpl.saveOrUpdateBatch(skuList);
//
//        // 设置剩余库存为sku的库存和
//        int stockSum = skuList.stream().collect(Collectors.summingInt(ProductSku::getSkuStock));
//        product.setRemainStock(stockSum);
//
//        // 设置商品sku最低价和最高价
//        skuList = skuList.stream().sorted((sku1, sku2) -> sku1.getPrice().compareTo(sku2.getPrice()))
//            .collect(Collectors.toList());
//        BigDecimal skuMinPrice = skuList.get(0).getPrice();
//        BigDecimal skuMaxPrice = skuList.get(skuList.size() - 1).getPrice();
//        product.setSkuMinPrice(skuMinPrice);
//        product.setSkuMaxPrice(skuMaxPrice);
//        product.setHasSku(ProductHasSkuEnum.HAS_SKU.getCode());
//
//        // 设置商品价格为最低价格的sku的价格
//        product.setUnitPrice(skuMinPrice);
//        product.setCostPrice(skuList.get(0).getCostPrice());
//        product.setOriginalPrice(skuList.get(0).getOriginalPrice());
//
//        productServiceImpl.saveOrUpdate(product);
//
//    }
//
//    // 删除商品规格值
//    private void deleteProductSpecValues(List<ProductSpecValue> values) {
//        if (!CollectionUtils.isEmpty(values)) {
//            values.forEach(value -> {
//                value.setState(CommonConst.STATE.INVALID);
//            });
//            productSpecValueServiceImpl.saveOrUpdateBatch(values);
//        }
//    }
//
//    // 删除商品sku
//    private void deleteProductSkus(List<ProductSku> skus) {
//        if (!CollectionUtils.isEmpty(skus)) {
//            skus.forEach(sku -> {
//                sku.setState(CommonConst.STATE.INVALID);
//            });
//            productSkuServiceImpl.saveOrUpdateBatch(skus);
//        }
//    }
//
//    // 删除商品规格和sku
//    private void deleteProductSpecRels(List<ProductSpecRel> productSpecRels) {
//        if (!CollectionUtils.isEmpty(productSpecRels)) {
//            productSpecRels.forEach(rel -> {
//                rel.setState(CommonConst.STATE.INVALID);
//            });
//            productSpecRelServiceImpl.saveOrUpdateBatch(productSpecRels);
//
//        }
//    }
//
//    /**
//     * 是否修改了规格
//     *
//     * @param productSpecRels      原先的商品规格关系
//     * @param productSpecRelValues 新的商品规格关系
//     * @return
//     */
//    private boolean isEditSpec
//    (List<ProductSpecRel> productSpecRels, List<ProductSpecRelValuePO> productSpecRelValues) {
//        if (CollectionUtils.isEmpty(productSpecRels) || productSpecRels.size() != productSpecRelValues.size()) {
//            return true;
//        }
//        // 判断是否修改过规格和顺序
//        // 原先的规格ID顺序
//        List<String> oldSpecIds = productSpecRels.stream().map(ProductSpecRel::getSpecId).collect(Collectors.toList());
//        // 新的规格ID顺序
//        List<String> newSpecIds = productSpecRelValues.stream().map(ProductSpecRelValuePO::getSpecId)
//            .collect(Collectors.toList());
//        // 是否修改
//        return !oldSpecIds.toString().equals(newSpecIds.toString());
//    }
//
//    /**
//     * 是否修改了sku
//     *
//     * @param values               原先的商品规格关系
//     * @param productSpecRelValues 新的商品规格关系
//     * @return
//     */
//    private boolean isEditSku(List<ProductSpecValue> values, List<ProductSpecRelValuePO> productSpecRelValues) {
//        // 没有修改规格和顺序，再判断规格值是否修改
//        if (CollectionUtils.isEmpty(values)) {
//            return true;
//        }
//        // 原先规格值的Map
//        Map<String, List<ProductSpecValue>> oldSpecValueMap = Maps.newHashMap();
//        for (ProductSpecValue oldValue : values) {
//            List<ProductSpecValue> valueList = oldSpecValueMap.get(oldValue.getSpecId());
//            if (valueList == null) {
//                valueList = Lists.newArrayList();
//                oldSpecValueMap.put(oldValue.getSpecId(), valueList);
//            }
//            valueList.add(oldValue);
//        }
//        // 规格值对比 是否修改过
//        for (ProductSpecRelValuePO productSpecRelValuePO : productSpecRelValues) {
//            // 如果有规格值没有id，说明修改了规格
//            if (productSpecRelValuePO.getProductSpecValues().stream()
//                .anyMatch(specRelValue -> specRelValue.getId() == null)) {
//                return true;
//            }
//            List<ProductSpecValue> oldValueList = oldSpecValueMap.get(productSpecRelValuePO.getSpecId());
//
//            // 对比老的规格值id和新的规格值id
//            List<Long> newValueIds = productSpecRelValuePO.getProductSpecValues().stream()
//                .map(ProductSpecValuePO::getId).collect(Collectors.toList());
//            List<Long> oldValueIds = oldValueList.stream().map(ProductSpecValue::getId).collect(Collectors.toList());
//
//            if (!newValueIds.toString().equals(oldValueIds.toString())) {
//                return true;
//            }
//
//        }
//        return false;
//    }
//
//    // 保存商品规格值
//    private Set<ProductSpecValue> saveProductSpecValues(String productId, String specId,
//                                                        List<ProductSpecValuePO> productSpecValues) {
//        // 需要是有序的,保证sku顺序正确
//        Date now = new Date();
//        Set<ProductSpecValue> addProductSpecValues = Sets.newLinkedHashSet();
//        // 新增或修改规格值
//        int valueViewSort = 1;
//        for (ProductSpecValuePO productSpecValuePO : productSpecValues) {
//            ProductSpecValue productSpecValue = new ProductSpecValue();
//            BeanUtils.copyProperties(productSpecValuePO, productSpecValue);
//            if (productSpecValue.getId() == null) {
//                productSpecValue.setCreateTime(now);
//            }
//            productSpecValue.setState(CommonConst.STATE.VALID);
//            productSpecValue.setValue(StringUtils.trim(productSpecValue.getValue()));
//            productSpecValue.setViewSort(valueViewSort);
//            productSpecValue.setProductId(productId);
//            productSpecValue.setSpecId(specId);
//            addProductSpecValues.add(productSpecValue);
//
//            valueViewSort++;
//        }
//        productSpecValueServiceImpl.saveOrUpdateBatch(addProductSpecValues);
//        return addProductSpecValues;
//    }
//
//    /**
//     * 商品定时上架
//     *
//     * @param productId
//     * @param storeStatus
//     * @param onSaleTime
//     */
//    private void productToOnSale(String productId, Integer storeStatus, Date onSaleTime) {
//        // 定时上架
//        String key = RedisConst.PRODUCT.PRODUCT_ON_SALE + productId;
//
//        StringRedisTemplate redisDb = RedisUtil.getRedisTemplate(RedisConst.DB_1);// 使用DB-1数据库
//
//        // 删除原先的定时key
//        redisDb.delete(key);
//        if (ProductStoreStatus.OFF_SALE.getCode().equals(storeStatus) && onSaleTime != null) {
//            long expireMillTime = onSaleTime.getTime() - System.currentTimeMillis();
//            redisDb.boundValueOps(key).set(productId, expireMillTime,
//                TimeUnit.MILLISECONDS);
//
//        }
//    }
//
//    @Override
//    public ApiResponse<ProductOtherInfoVO> showProductOtherInfo(String productId) {
//        ProductOtherInfoVO productOtherInfoVO = new ProductOtherInfoVO();
//        productOtherInfoVO.setProductId(productId);
//
//        // 商品预约字段信息
//        List<ProductReserveFieldVO> productReserveFields = productReserveFieldManageServiceImpl.showProductReserveFields(productId);
//        productOtherInfoVO.setProductReserveFields(productReserveFields);
//
//        //商品预约时间配置
//        List<ProductReserveTimeVO> reserveTimes = productReserveTimeManageServiceImpl.findByProductId(productId);
//        productOtherInfoVO.setProductReserveTimes(reserveTimes);
//
//
//        return ResponseUtil.success(productOtherInfoVO);
//    }
//
//    @Override
//    public ApiResponse<List<ProductReserveTimeVO>> showReserveTimes(String productId) {
//        List<ProductReserveTimeVO> reserveTimes = productReserveTimeManageServiceImpl.findByProductId(productId);
//        return ResponseUtil.success(reserveTimes);
//    }
//
//}
